// package main

// import (
// 	"fmt"
// 	"sync"
// 	"sync/atomic"
// )

// type singleton struct {
// }

// var (
// 	instance    *singleton
// 	initialized uint32
// 	mu          sync.Mutex
// )

// func Instance() *singleton {
// 	if atomic.LoadUint32(&initialized) == 1 {
// 		return instance
// 	}
// 	fmt.Println(initialized)

// 	mu.Lock()
// 	defer mu.Unlock()
// 	if instance == nil {
// 		defer atomic.StoreUint32(&initialized, 1)
// 		instance = &singleton{}
// 	}
// 	return instance
// }
// func main() {
// 	result := Instance()
// 	b := Instance()
// 	c := Instance()

// 	fmt.Println(result == b)
// 	fmt.Printf("result,%v,%v，%v", &result, &b, &c)
// }

// ====================================
// sync.Once实现
package main

import (
	"fmt"
	"sync"
	"sync/atomic"
	"time"
)

type Once struct {
	m    sync.Mutex
	done uint32
}

func (o *Once) Do(f func()) {
	if atomic.LoadUint32(&o.done) == 1 {
		return
	}
	o.m.Lock()
	defer o.m.Unlock()
	if o.done == 0 {
		defer atomic.StoreUint32(&o.done, 1)
		f()
	}
}

func t() {
	fmt.Println("ddddd")

}

var c chan int

func main() {
	var a Once
	go a.Do(t)
	go a.Do(t)
	go a.Do(t)
	go a.Do(t)
	go a.Do(t)

	time.Sleep(10 * time.Second)
}

// ====================================
// 单例模式的演变
// type Once_Demo struct {
// 	m     sync.Mutex
// 	count uint32
// }

// func (o *Once_Demo) DoIt(f func()) {
// 	if atomic.LoadUint32(&o.count) == 1 {
// 		return
// 	}
// 	o.m.Lock()
// 	defer o.m.Unlock()
// 	if o.count == 0 {
// 		atomic.StoreUint32(&o.count, 1)
// 		f()
// 	}
// }
// ====================================
